package dawn.util;

import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;

public class Util {
    /**
     * 处理csv文件中为空的数据，当为空时返回null，否则返回数字
     * 
     * @param content
     * @return
     */
    public static Integer strToInteger(String content) {
        if (content == null || "".equals(content)) {
            return null;
        }
        return Integer.valueOf(content.trim());
    }

    /**
     * 处理csv文件中为空的数据，当为空时返回null，否则返回数字
     * 
     * @param content
     * @return
     */
    public static Float strToFloat(String content) {
        if (content == null || "".equals(content)) {
            return null;
        }
        if (content.endsWith("%"))
            return Float.parseFloat(content.substring(0, content.length() - 1));
        else
            return Float.valueOf(content.trim());
    }

    private static Random random = new Random(System.currentTimeMillis());

    /**
     * 在 start（包括）和end（不包括）之间均匀分布的 int 值。
     * 
     * @param start
     * @param end
     * @return
     */
    public static int randomInt(int start, int end) {

        return random.nextInt(end - start) + start;
    }

    /**
     * 在 start（包括）和end（不包括）之间均匀分布的 Float 值。
     * 
     * @param start
     * @param end
     * @return
     */
    public static float randomFloat(float start, float end) {

        return (float) (random.nextInt((int) (end * 100 - start * 100)) + start * 100) / 100;
    }

    public static float random() {
        return random.nextFloat();
    }

    /**
     * 普通查找法
     * 
     * @detail 效率最低
     * 
     * @param array
     * @param uid
     * @return
     */
    public static int commonSearch(int[] array, int uid) {
        for (int i = 0; i < array.length; i++) {
            if (uid == array[i]) {
                return i; // 返回该元素在数组中的下标
            }
        }
        return -1; // 不存在该元素则返回-1
    }

    /**
     * 导入csv数据时把数组形式的转为int型的数组
     * 
     * @param strArray
     * @return
     */
    public static int[] strArrayToIntArray(String[] strArray) {
        int[] intArray = new int[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            intArray[i] = Integer.parseInt(strArray[i]);
        }
        return intArray;
    }

    /**
     * 导入csv数据时把数组形式的转为Integer型的数组
     * 
     * @param strArray
     * @return
     */
    public static Integer[] strArrayToIntegerArray(String[] strArray) {
        Integer[] integerArray = new Integer[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            integerArray[i] = Integer.parseInt(strArray[i]);
        }
        return integerArray;
    }

    /**
     * 导入csv数据时把数组形式的转为double型的数组
     * 
     * @param strArray
     * @return
     */
    public static Double[] strArrayToDoubleArray(String[] strArray) {
        Double[] doubleArray = new Double[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            doubleArray[i] = Double.parseDouble(strArray[i]);
        }
        return doubleArray;
    }

    /**
     * 导入csv数据时把数组形式的转为Float型的数组
     * 
     * @param strArray
     * @return
     */
    public static Float[] strArrayToFloatArray(String[] strArray) {
        Float[] floatArray = new Float[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            if (strArray[i].endsWith("%"))
                floatArray[i] = Float.parseFloat(strArray[i].substring(0,
                        strArray[i].length() - 1));
            else
                floatArray[i] = Float.parseFloat(strArray[i]);
        }
        return floatArray;
    }

    public static void main(String[] args) {
        System.out.println(randomFloat(0,1));
//        System.out.println(random());
//        System.out.println(random());
//        System.out.println(random());
//        System.out.println(random());
//        System.out.println(random());
//        System.out.println(random());

    }

    /**
     * 将Map按照value进行升序排序。
     * 
     * @param map
     * @return
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortByValueAsc(
            Map<K, V> map) {
        List<Entry<K, V>> list = new LinkedList<Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Entry<K, V>>() {
            public int compare(Entry<K, V> o1, Entry<K, V> o2) {

                Comparable<V> v1 = o1.getValue();
                V v2 = o2.getValue();
                if (v1 == null) {
                    if (v2 == null) {
                        return 0;
                    } else {
                        return -1;
                    }
                } else {
                    if (v2 == null) {
                        return 1;
                    } else {
                        return v1.compareTo(v2);
                    }
                }
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        Iterator<Entry<K, V>> it = list.iterator();
        while (it.hasNext()) {
            Entry<K, V> entry = it.next();
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    /**
     * 将Map按照value进行降序排序。
     * 
     * @param map
     * @return
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortByValueDesc(
            Map<K, V> map) {
        List<Entry<K, V>> list = new LinkedList<Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Entry<K, V>>() {
            public int compare(Entry<K, V> o1, Entry<K, V> o2) {

                Comparable<V> v2 = o2.getValue();
                V v1 = o1.getValue();
                if (v1 == null) {
                    if (v2 == null) {
                        return 0;
                    } else {
                        return -1;
                    }
                } else {
                    if (v2 == null) {
                        return 1;
                    } else {
                        return v2.compareTo(v1);
                    }
                }
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        Iterator<Entry<K, V>> it = list.iterator();
        while (it.hasNext()) {
            Entry<K, V> entry = it.next();
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    /**
     * 计算暴击，格挡，精准，任性的转换 
     * 
     * @param income 基础值
     * @param tax_line 数值段数组：{ 0, 199f, 1399f };
     * @param tax_rate 转换率数组：{ 0.0003f, 0.0001f, 0.00005f };
     * @param tax_sub 各个段的上一级的最高转换值：{ 0f, 0.0597f, 0.1797f };
     * @return
     */
    public static float ComputeTax(float income, float[] tax_line,
            float[] tax_rate, float[] tax_sub) {
        int i_tax_level = 0; //为了计算简便，把数值进行分档
        while (i_tax_level < tax_line.length && income > tax_line[i_tax_level]) {
            i_tax_level++;
        };
        if (i_tax_level > 0) {
            float f_tax = tax_sub[i_tax_level - 1]
                    + (income - tax_line[i_tax_level - 1])
                    * tax_rate[i_tax_level - 1]; //算税的公式
            return f_tax;
        } else {
            return 0f;
        }
    }
}
